type math/big.nat
224 uses
math/big (current package)
decimal.go#L55: func (x *decimal) init(m nat, shift int) {
decimal.go#L72: m = nat(nil).shr(m, s)
decimal.go#L78: m = nat(nil).shl(m, uint(shift))
float.go#L71: mant nat
float.go#L577: func fnorm(m nat) int64 {
float.go#L691: func msb32(x nat) uint32 {
float.go#L709: func msb64(x nat) uint64 {
float.go#L1233: t := nat(nil).shl(y.mant, uint(ey-ex))
float.go#L1244: t := nat(nil).shl(x.mant, uint(ex-ey))
float.go#L1278: t := nat(nil).shl(y.mant, uint(ey-ex))
float.go#L1289: t := nat(nil).shl(x.mant, uint(ex-ey))
float.go#L1350: xadj = make(nat, len(x.mant)+d)
float.go#L1362: var r nat
ftoa.go#L186: mant := nat(nil).set(x.mant)
ftoa.go#L200: var tmp nat
ftoa.go#L332: m = nat(nil).shl(m, uint(x.prec-w))
ftoa.go#L334: m = nat(nil).shr(m, uint(w-x.prec))
ftoa.go#L383: m = nat(nil).shl(m, n-w)
ftoa.go#L385: m = nat(nil).shr(m, w-n)
int.go#L27: abs nat // absolute value of the integer
int.go#L96: z.abs = nat(abs).norm()
int.go#L221: _, z.abs = nat(nil).div(z.abs, x.abs, y.abs)
int.go#L352: func low32(x nat) uint32 {
int.go#L360: func low64(x nat) uint64 {
int.go#L504: var mWords nat
int.go#L1044: t := nat(nil).sub(x.abs, natOne)
int.go#L1076: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1077: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1095: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1106: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1107: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1121: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1128: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1139: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1140: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1158: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1169: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1170: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1188: y1 := nat(nil).sub(y.abs, natOne)
nat.go#L35: type nat []Word
nat.go#L38: natOne = nat{1}
nat.go#L39: natTwo = nat{2}
nat.go#L40: natFive = nat{5}
nat.go#L41: natTen = nat{10}
nat.go#L44: func (z nat) clear() {
nat.go#L50: func (z nat) norm() nat {
nat.go#L58: func (z nat) make(n int) nat {
nat.go#L64: return make(nat, 1)
nat.go#L69: return make(nat, n, n+e)
nat.go#L72: func (z nat) setWord(x Word) nat {
nat.go#L81: func (z nat) setUint64(x uint64) nat {
nat.go#L93: func (z nat) set(x nat) nat {
nat.go#L99: func (z nat) add(x, y nat) nat {
nat.go#L125: func (z nat) sub(x, y nat) nat {
nat.go#L153: func (x nat) cmp(y nat) (r int) {
nat.go#L180: func (z nat) mulAddWW(x nat, y, r Word) nat {
nat.go#L195: func basicMul(z, x, y nat) {
nat.go#L213: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
nat.go#L248: func karatsubaAdd(z, x nat, n int) {
nat.go#L255: func karatsubaSub(z, x nat, n int) {
nat.go#L270: func karatsuba(z, x, y nat) {
nat.go#L370: func alias(x, y nat) bool {
nat.go#L377: func addAt(z, x nat, i int) {
nat.go#L408: func (z nat) mul(x, y nat) nat {
nat.go#L499: func basicSqr(z, x nat) {
nat.go#L522: func karatsubaSqr(z, x nat) {
nat.go#L560: func (z nat) sqr(x nat) nat {
nat.go#L618: func (z nat) mulRange(a, b uint64) nat {
nat.go#L628: return z.mul(nat(nil).setUint64(a), nat(nil).setUint64(b))
nat.go#L631: return z.mul(nat(nil).mulRange(a, m), nat(nil).mulRange(m+1, b))
nat.go#L636: func getNat(n int) *nat {
nat.go#L637: var z *nat
nat.go#L639: z = v.(*nat)
nat.go#L642: z = new(nat)
nat.go#L648: func putNat(x *nat) {
nat.go#L655: func (x nat) bitLen() int {
nat.go#L664: func (x nat) trailingZeroBits() uint {
nat.go#L676: func same(x, y nat) bool {
nat.go#L681: func (z nat) shl(x nat, s uint) nat {
nat.go#L706: func (z nat) shr(x nat, s uint) nat {
nat.go#L729: func (z nat) setBit(x nat, i uint, b uint) nat {
nat.go#L759: func (x nat) bit(i uint) uint {
nat.go#L770: func (x nat) sticky(i uint) uint {
nat.go#L790: func (z nat) and(x, y nat) nat {
nat.go#L806: func (z nat) andNot(x, y nat) nat {
nat.go#L823: func (z nat) or(x, y nat) nat {
nat.go#L842: func (z nat) xor(x, y nat) nat {
nat.go#L863: func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
nat.go#L899: func (z nat) expNN(x, y, m nat) nat {
nat.go#L919: _, z = nat(nil).div(z, x, m)
nat.go#L945: var q nat
nat.go#L956: var zz, r nat
nat.go#L999: func (z nat) expNNWindowed(x, y, m nat) nat {
nat.go#L1002: var zz, r nat
nat.go#L1006: var powers [1 << n]nat
nat.go#L1063: func (z nat) expNNMontgomery(x, y, m nat) nat {
nat.go#L1069: _, x = nat(nil).div(nil, x, m)
nat.go#L1073: rr := make(nat, numWords)
nat.go#L1090: RR := nat(nil).setWord(1)
nat.go#L1091: zz := nat(nil).shl(RR, uint(2*numWords*_W))
nat.go#L1092: _, RR = nat(nil).div(RR, zz, m)
nat.go#L1099: one := make(nat, numWords)
nat.go#L1104: var powers [1 << n]nat
nat.go#L1147: _, zz = nat(nil).div(nil, zz, m)
nat.go#L1158: func (z nat) bytes(buf []byte) (i int) {
nat.go#L1192: func (z nat) setBytes(buf []byte) nat {
nat.go#L1213: func (z nat) sqrt(x nat) nat {
nat.go#L1226: var z1, z2 nat
natconv.go#L109: func (z nat) scan(r io.ByteScanner, base int, fracOk bool) (res nat, b, count int, err error) {
natconv.go#L259: func (x nat) utoa(base int) []byte {
natconv.go#L264: func (x nat) itoa(neg bool, base int) []byte {
natconv.go#L332: q := nat(nil).set(x)
natconv.go#L370: func (q nat) convertWords(s []byte, b Word, ndigits int, bb Word, table []divisor) {
natconv.go#L374: var r nat
natconv.go#L444: bbb nat // divisor
natconv.go#L455: func (z nat) expWW(x, y Word) nat {
natconv.go#L456: return z.expNN(nat(nil).setWord(x), nat(nil).setWord(y), nil)
natconv.go#L484: var larger nat
natconv.go#L488: table[0].bbb = nat(nil).expWW(bb, Word(leafSize))
natconv.go#L491: table[i].bbb = nat(nil).sqr(table[i-1].bbb)
natconv.go#L496: larger = nat(nil).set(table[i].bbb)
natdiv.go#L505: func (z nat) div(z2, u, v nat) (q, r nat) {
natdiv.go#L532: func (z nat) divW(x nat, y Word) (q nat, r Word) {
natdiv.go#L552: func (x nat) modW(d Word) (r Word) {
natdiv.go#L554: var q nat
natdiv.go#L579: func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
natdiv.go#L621: func (q nat) divBasic(u, v nat) {
natdiv.go#L716: func (z nat) divRecursive(u, v nat) {
natdiv.go#L722: temps := make([]*nat, recDepth)
natdiv.go#L741: func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
prime.go#L86: func (n nat) probablyPrimeMillerRabin(reps int, force2 bool) bool {
prime.go#L87: nm1 := nat(nil).sub(n, natOne)
prime.go#L90: q := nat(nil).shr(nm1, k)
prime.go#L92: nm3 := nat(nil).sub(nm1, natTwo)
prime.go#L95: var x, y, quotient nat
prime.go#L150: func (n nat) probablyPrimeLucas() bool {
prime.go#L169: d := nat{1}
prime.go#L170: t1 := nat(nil) // temp
prime.go#L216: s := nat(nil).add(n, natOne)
prime.go#L219: nm2 := nat(nil).sub(n, natTwo) // n-2
prime.go#L249: natP := nat(nil).setWord(p)
prime.go#L250: vk := nat(nil).setWord(2)
prime.go#L251: vk1 := nat(nil).setWord(p)
prime.go#L252: t2 := nat(nil) // temp
rat.go#L77: func quotToFloat32(a, b nat) (f float32, exact bool) {
rat.go#L111: var a2, b2 nat
rat.go#L123: var q nat
rat.go#L175: func quotToFloat64(a, b nat) (f float64, exact bool) {
rat.go#L209: var a2, b2 nat
rat.go#L221: var q nat
rat.go#L310: babs = nat(nil).set(babs) // make a copy
rat.go#L426: return &Int{abs: nat{1}}
rat.go#L457: func mulDenom(z, x, y nat) nat {
rat.go#L471: func (z *Int) scaleDenom(x *Int, f nat) {
ratconv.go#L181: pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil) // use underlying array of z.b.abs
ratconv.go#L345: q, r := nat(nil).div(nat(nil), x.a.abs, x.b.abs)
ratconv.go#L349: p = nat(nil).expNN(natTen, nat(nil).setUint64(uint64(prec)), nil)
ratconv.go#L353: r, r2 := r.div(nat(nil), r, x.b.abs)
ratconv.go#L360: q = nat(nil).add(q, natOne)
ratconv.go#L361: r = nat(nil).sub(r, p)